// 用于获取req.body
const bodyParser = require('body-parser')
const jsonServer = require('json-server')
// 创建json-server实例
const server = jsonServer.create()
const jsonDB = require('./db')
// 将路由配置表传入，生成路由表
const router = jsonServer.router(jsonDB.dbJson)
const middlewares = jsonServer.defaults()
// 挂载组件
// 使用了body-parser就可以用这句话来解决request entity too large问题
server.use(bodyParser.json({limit : "2100000kb"}))
// cors跨域配置 在服务器端设置了header
server.all('*', function (req, res, next) {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Headers', 'Content-Type, Content-Length, Authorization, Accept, X-Requested-With, Current-Page');
  res.header('Access-Control-Allow-Methods', 'PUT, POST, GET, DELETE, OPTIONS');
  if (req.method == 'OPTIONS') {
      res.sendStatus(200);
  } else {
      next();
  }
});
// 将当前POST请求切换成GET请求
server.use((req, res, next) => {
  if (req.method === 'POST') {
    req.method = 'GET'
  }
  // Continue to JSON Server router
  next()
})
// 对比函数对象
 let compareObj = {
  // 比较两个对象是否相等
  compare: function (oldData, newData) {
    // 类型为基本类型时,如果相同,则返回true
    if (oldData === newData) return true
    if (compareObj.isObject(oldData) && compareObj.isObject(newData) && Object.keys(oldData).length === Object.keys(newData).length) {
      // 类型为对象并且元素个数相同
      // 遍历所有对象中所有属性,判断元素是否相同
      for (const key in oldData) {
        if (oldData.hasOwnProperty(key)) {
          if (!compareObj.compare(oldData[key], newData[key])) {
            // 对象中具有不相同属性 返回false
            return false
          }
        }
      }
    } else if (compareObj.isArray(oldData) && compareObj.isArray(oldData) && oldData.length === newData.length) {
      // 类型为数组并且数组长度相同
      for (let i = 0, length = oldData.length; i < length; i++) {
        if (!compareObj.compare(oldData[i], newData[i])) {
          // 如果数组元素中具有不相同元素,返回false
          return false
        }
      }
    } else {
      // 其它类型,均返回false
      return false
    }
    // 走到这里,说明数组或者对象中所有元素都相同,返回true
    return true
  },
  // 判断此类型是否是Array类型
  isObject: function (obj) {
    return Object.prototype.toString.call(obj) === '[object Object]'
  },
  // 判断此对象是否是Object类型
  isArray: function (arr) {
    return Object.prototype.toString.call(arr) === '[object Array]'
  }
}
// 按时间数组排序函数
function bubbleSort (arr) {
  let len = arr.length
  for (var i = 0; i < len; i++) {
    for (let j = 0; j < len - 1 - i; j++) {
      if (arr[j].date > arr[j + 1].date) { // 相邻元素两两对比
        let temp = arr[j + 1] // 元素交换
        arr[j + 1] = arr[j]
        arr[j] = temp
      }
    }
  }
}
// 补0函数
function padLeftZero (str) {
  return ('00' + str).substr(str.length)
}
// 初始化数据
let REALSHOW = jsonDB.dbFunc.realshow
let ADMINUSERDATA = jsonDB.dbFunc.adminUser() 
let SHOWDATA = jsonDB.dbFunc.shows()
let THEATHERDATA = jsonDB.dbFunc.theaters()
let USERDATA = jsonDB.dbFunc.user().userdata
bubbleSort(USERDATA)
// 根据THEATHERDATA来获取当前所有剧目的location数据
let location = []
function theaterLocation () {
   // 遍历存储
   for (let i = 0; i < THEATHERDATA.length; i++) {
    let ctheather = THEATHERDATA[i]
    let cchildren = []
    let d = {}
    d.label = ctheather.theaterName
    d.value = ctheather.path
    location.push(d)
    if (THEATHERDATA[i].theatreHall.length > 0) {
      for (let y = 0; y < ctheather.theatreHall.length; y++) {
        let chall = ctheather.theatreHall
        let c = {}
        c.label = chall[y].hallName
        c.value = chall[y].hallId
        cchildren.push(c)
      }
    }
    location[i].children = cchildren
  }
}
theaterLocation()

// 合并mock数据以及真实演出数据
function margedata () {
 for (let i = 0; i < REALSHOW.length; i++) {
  REALSHOW[i].theaterShows.showInfo.forEach(s => {
    SHOWDATA[i].theaterShows.showInfo.push(s)
  })
 } 
}
margedata()
// 设置当天的日期数据
let now = new Date()
let nowyear = now.getFullYear()
let nowmonth = now.getMonth() + 1 < 10 ? '0' + (now.getMonth() + 1) : (now.getMonth() + 1)
let nowday = now.getDate() < 10 ? '0' + now.getDate() : now.getDate()
const NOW = `${nowyear}-${nowmonth}-${nowday}`
// 登录请求
server.get('/login', (req, res) => {
  // 通过ES6解构的语法获取用户名和密码
  let { username, password } = req.body
  let currentuser = null
  let hasUser = ADMINUSERDATA.some(user => {
    if (user.username === username && user.password === password) {
      currentuser = user
      return true
    } else {
      return false
    }
  })
  if (hasUser) {
    res.status(200).send([{ msg: '登录成功' }, currentuser])
  } else {
    // 如果没有这么一个人
    res.status(203).send({ msg: '登录失败' })
  }
})
// 获取侧边栏数据
server.get('/menus', (req, res) => {
  let data = THEATHERDATA
  res.send(data)
})
// 通过获取当前月所有演出数据
server.get('/getmonthdata', (req, res) => {
  let currentmonth = padLeftZero(req.url.split('?')[1].split('=')[1] + '')
  let resdata = []
  let response = {}
  for (let i = 0; i < SHOWDATA.length; i++) {
    let data = {}
    data.id = SHOWDATA[i].id
    data.path = SHOWDATA[i].path
    data.show = []
    SHOWDATA[i].theaterShows.showInfo.forEach(item => {
      // 循环查找
      let mon = item.date.split('-')[1]
      if(mon === currentmonth) {
        // 用delete会操作原数据的内容
        // delete item.priceRangestart
        let monshow = {}
        // 我们这里要取出 演出名/日期/剧院/演出厅/演出类型/剧院path
        monshow.date = item.date
        monshow.hall = item.hall
        monshow.theater = item.theater
        monshow.theaterName = item.theaterName
        monshow.type = item.type
        monshow.showName = item.showName
        data.show.push(monshow)
      }
    })
    bubbleSort(data.show)
    resdata.push(data)
  }
  if (resdata.length > 0) {
    response = {
      "msg" : "数据获取成功",
      "showData": resdata
    }
    res.status(200).send(response)
  } else {
    response = {
      "msg" : "数据获取失败",
    }
    res.status(203).send(response)
  }
})
// 获取最近用户评论
server.get('/getnewcomments', (req, res) => {
  let commentsdata = []
  let data
  USERDATA.forEach(u => {
    u.comments.forEach(c => {
      c.username = u.username
      c.avatarimg = u.avatarimg
      c.sex = u.sex
      commentsdata.push(c)
    })
  })
  for (var i = 0; i < commentsdata.length; i++) {
    for (let j = 0; j < commentsdata.length - 1 - i; j++) {
      if (commentsdata[j].date.split(' ')[0] > commentsdata[j + 1].date.split(' ')[0]) { // 相邻元素两两对比
        let temp = commentsdata[j + 1] // 元素交换
        commentsdata[j + 1] = commentsdata[j]
        commentsdata[j] = temp
      }
    }
  }
  data = commentsdata.reverse().splice(0, 10)
  res.status(200).send(data)
})
// 获取当前日期的演出
server.get('/gettoday', (req, res) => {
  let day = req.url.split('?')[1].split('=')[1]
  let show = []
  let dayshow = []
  let response = {}
  SHOWDATA.forEach(item => {
    // 将所有剧场的演出全部放入一个数组
    Array.prototype.push.apply(show, item.theaterShows.showInfo)
  })
  show.forEach(s => {
    if (s.date === day) {
      let dshow = {}
        // 我们这里要取出 演出名/日期/剧院/演出厅/演出类型/剧院path
        dshow.pic = s.pic
        dshow.date = s.date
        dshow.hall = s.hall
        dshow.theater = s.theater
        dshow.theaterName = s.theaterName
        dshow.type = s.type
        dshow.showName = s.showName
      dayshow.push(dshow)
    }
  })
  if (dayshow.length > 0) {
    response = {
      "msg" : "今天有演出",
      "hasshow": true,
      "showData": dayshow
    }
    res.status(200).send(response)
  } else {
    response = {
      "msg" : "今天无演出",
      "hasshow": false,
    }
    res.status(200).send(response)
  }
})
// 获取单个剧院的全部座位数据，通过?path=来传递参数，还要获取当前厅的演出数据
server.get('/getTheaterInfo', (req, res) => {
  let star = req.url.indexOf('=')
  let path = req.url.split('?')[1].split('&')[0].split('=')[1]
  let hallnum = req.url.split('?')[1].split('&')[1].split('=')[1]
  let currentdata = {}
  let currentshow = []
  let response = {}
  let hallshow = []
  let hallname = []
  if (star !== -1) {
    // 这里是查找到对应的剧院
    THEATHERDATA.forEach(info => {
      if (info.path === path) {
        currentdata = info
      }
    })
    // 根据location的数据来查出这个剧院有几个演出厅，并且把演出厅的名字整合成一个数组
    let hallid = location.findIndex(item => {
      return item.value === path
    })
    // 这里是查找对应剧院的所有演出
    SHOWDATA.forEach(info => {
      if (info.path === path) {
        let cshows = info.theaterShows.showInfo
        location[hallid].children.forEach(item => {
          hallname.push(item.label)
        })
        // 取出对应演出厅的演出数据
        cshows.forEach(item => {
          // 演出的日期和当前日期的比较 只显示比当前日期晚的演出
          if(item.hall === hallname[hallnum] && item.date >= NOW) {
            // delete因为引用类型的原因删除会操作原数据，用深拷贝就不会影响后面的数据
            let show = JSON.parse(JSON.stringify(item))
            // console.log(item.date, NOW)
            delete show.pricemap
            currentshow.push(show)
          }
        })
        // 对数据排序
        bubbleSort(currentshow)
      }
    })
    // 组装需要返回的数据
    response = {
      "msg" : "数据获取成功",
      "theaterData": currentdata,
      "showData": currentshow
    }
    res.status(200).send(response)
  } else {
    res.status(200).send([{ msg: '获取数据失败' }])
  }
})
// 剧目修改请求
server.get('/editShow', (req, res) => {
  // 这里是根据传递进来的当前剧院path和当前剧目id来
  // 拿到的mock是一个函数，立即执行之后就会发现每次获得的值都是个新的数据
  let url = req.url.split('?')[1].split('&')
  let allShows = []
  let currentshow = []
  // 返回的数据
  let response = {}
  let path = url[0].split('=')[1]
  let id = url[1].split('=')[1]
  // 查询对应剧院的所有剧目
  SHOWDATA.forEach(info => {
    if (info.path === path) {
      allShows = info.theaterShows.showInfo
      console.log(allShows.length)
    }
  })
  // 查询对应id
  function sFn (p) {
    return p.id === id
  }
  // 再从所有剧目中，通过id查找对应剧目
  let showId = allShows.findIndex(sFn)
  if (showId !== -1) {
    currentshow = JSON.parse(JSON.stringify(allShows[showId]))
    response = {
      "msg" : "数据获取成功",
      "currentshow": currentshow
    }
    res.status(200).send(response)
  } else {
    res.status(200).send([{ msg: '获取数据失败' }])
  }
})
// 删除剧目请求
server.get('/deletshow', (req, res) => {
  let url = req.url.split('?')[1].split('&')
  let path = url[0].split('=')[1]
  let sid = url[1].split('=')[1]
  let hallnum = url[2].split('=')[1]
  let hallname = []
// 根据location的数据来查出这个剧院有几个演出厅，并且把演出厅的名字整合成一个数组
  let hallid = location.findIndex(item => {
   return item.value === path
 })
 location[hallid].children.forEach(item => {
  hallname.push(item.label)
})
  // 先操作原数据再取出操作后的数据
  let alls = []
  let showidx 
  SHOWDATA.forEach(info => {
    if (info.path === path) {
      info.theaterShows.showInfo.forEach((item, idy) => {
        // 如果id相同，那就不要放入传输的数据中，并且保存这个idy
        if(item.id === sid && item.hall === hallname[hallnum]) {
          showidx = idy
        } else if (item.id !== sid && item.hall === hallname[hallnum] && item.date >= NOW ){
          // 如果id不相同就相当于要保存起来
            alls.push(item)
        }
      })
    }
  })
  // 原数据中删除这个数据
  SHOWDATA[hallid].theaterShows.showInfo.splice(showidx, 1)
  // 再从所有剧目中，通过id查找对应剧目
  if (showidx) {
    let currentshow = []
    // 这个返回的数据也应该按照获取的时候来处理
    // 取出对应演出厅的演出数据
    alls.forEach(item => {
      if(item.hall === hallname[hallnum]) {
        let show = JSON.parse(JSON.stringify(item))
        delete show.pricemap
        currentshow.push(show)
      }
    })
    // 对数据排序
    bubbleSort(currentshow)
    response = {
      "msg" : "删除成功",
      "currentshow": currentshow
    }
    res.status(200).send(response)
  } else {
    res.status(200).send([{ msg: '删除失败' }])
  }
})
// 编辑剧目完成请求
server.get('/edit', (req, res) => {
  // 通过传入的数据解析，当前是哪个剧院的哪场演出
  let postData = req.body
  let path = postData.theater
  let id = postData.id
  // 当前剧院所有演出
  let allShows = []
  // 要修改演出的原始数据
  let oldshowdata = {}
  // 查询对应剧院的所有剧目
  SHOWDATA.forEach(info => {
    if (info.path === path) {
      allShows = info.theaterShows.showInfo
    }
  })
  // 查询对应id
  function sFn (p) {
    return p.id === id
  }
  // 再从所有剧目中，通过id查找对应剧目
  let showId = allShows.findIndex(sFn)
  if (showId !== -1) {
    // 查找到有这个剧目信息
    // 储存原始数据
    oldshowdata = allShows[showId]
    // 比较原始的和传入的数据是否有变化
    let isChange = compareObj.compare(oldshowdata, postData)
    // 前后两次数值改变了，就要拷贝数据存起来，并且将最新的数据返回
    if (isChange === false) {
      let len = postData.priceRange.length - 1
      // 这个数字代表了我们在priceRange中删除了哪些等级的价格
      let num = []
      // 要修改传入数据的price数据
      postData.price = `${postData.priceRange[0].price}-${postData.priceRange[len].price}`
      // console.log(postData)
      // 要通过循环修改priceRange的class以及删除没有对应价格数据的seatmap
      postData.priceRange.forEach((item, index) => {
        item.class = index
        // 把价格相等的pricemap数据保存进一个新数组
        num.push(postData.pricemap.find(xtem => { return xtem.price === item.price }))
      })
      // 覆盖上新的pricemap
      postData.pricemap = num
      // 要将传入的数据拷贝到原数据中
      for (let key in oldshowdata) {
        oldshowdata[key] = postData[key]
      }
      // console.log(oldshowdata)
      res.status(200).send({msg: '剧目修改成功'})
    } else {
      // 如果没有改变，就直接返回数值
      res.status(200).send({msg: '两次数据没有变化'})
    }
  } else {
    // 没有查找到当前剧目数据
    res.status(200).send({msg: '没有这个剧目数据'})
  }
})
// 修改剧场座位操作
server.get('/seatmap', (req, res) => {
  // 所有的剧场信息
  let postData = req.body
  // console.log(postData)
  let path = postData.path
  let id = postData.activename
  let response = {}
  // 查询对应剧院函数
   function tFn (p) {
    return p.path === path
  }
  // 查找到当前传递过来的path对应的剧院
  let theaterId = THEATHERDATA.findIndex(tFn)
  if (theaterId !== -1) {
    // 通过path查找到了对应的剧院
    // 这里通过id来确定是对应剧院的哪个演出厅，并且修改数据
    // console.log(postData.seatmap.hallSeatMap)
    let changed = compareObj.compare(THEATHERDATA[theaterId].theatreHall[parseInt(id)].hallSeatMap, postData.seatmap.hallSeatMap)
    console.log(changed)
    if (!changed) {
      THEATHERDATA[theaterId].theatreHall[parseInt(id)].hallSeatMap = postData.seatmap.hallSeatMap
      response = {
        msg:'修改成功',
        theaterData: THEATHERDATA[theaterId]
      }
      res.status(200).send(response)
    } else {
      res.status(202).send({msg:'两次数据没有改变'})
    }
  } else {
    res.status(202).send({msg:'没有当前演出厅信息'})
  }
})
// 添加演出厅操作
server.get('/addhall', (req, res) => {
  let postData = req.body
  postData.hallinfo.hallSeatMap = []
  let path = postData.path
  let width = postData.hallinfo.hallWidth
  let size = postData.hallinfo.hallWidth * postData.hallinfo.hallHeight
  let currentTheater = []
  // 通过for循环，初始化seatmap
  for (let i = 0; i < size; i++) {
    let from = {}
    let row = Math.floor(i / width)
    from.id = `${row}-${i - row * width}`
    from.isSeat = true
    postData.hallinfo.hallSeatMap.push(from)
  }
  // 查询对应剧院
  function tFn (p) {
    return p.path === path
  }
  // 查找到当前传递过来的id对应的剧院
  let theaterId = THEATHERDATA.findIndex(tFn)
  if (theaterId !== -1) {
    postData.hallinfo.hallId = `${THEATHERDATA[theaterId].theatreHall.length}`
    THEATHERDATA[theaterId].theatreHall.push(postData.hallinfo)
    currentTheater = THEATHERDATA[theaterId]
    response = {
      msg:'添加演出厅成功',
      theaterData: currentTheater
    }
    // 重新获取location
    theaterLocation()
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'添加演出厅失败'})
  }
})
// 删除演出厅操作
server.get('/deletehall', (req, res) => {
  let postData = req.body
  let path = postData.path
  let id = parseInt(postData.hallId)
  let currentTheater = []
  let response = {}
  // 查询对应剧院
  function tFn (p) {
    return p.path === path
  }
  // 查找到当前传递过来的id对应的剧院
  let theaterId = THEATHERDATA.findIndex(tFn)
  // 如果存在这个id
  if (theaterId !== -1) {
    THEATHERDATA[theaterId].theatreHall.splice(id, 1)
    // 重设每个剧场的hallid
    for (let i = 0; i < THEATHERDATA[theaterId].theatreHall.length; i++) {
      THEATHERDATA[theaterId].theatreHall[i].hallId = i + ''
    }
    currentTheater = THEATHERDATA[theaterId]
    response = {
      msg: '删除成功',
      theaterData: currentTheater
    }
    // 重新获取location
    theaterLocation()
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'删除失败'})
  }
})
// 获取所有剧目数据操作
server.get('/getallshow', (req, res) => {
  let start = req.url.split('?')[1].split('&')[0].split('=')[1]
  let end = req.url.split('?')[1].split('&')[1].split('=')[1]
  console.log(start, end)
  // 用于放所有的演出数据
  let show = []
  // 返回的数据
  let response = {}
  console.log(NOW)
  SHOWDATA.forEach(item => {
    // 将所有剧场的演出全部放入一个数组
    Array.prototype.push.apply(show, item.theaterShows.showInfo)
  })
  // 按日期对全部数据进行排序
  let len = show.length
  for (var i = 0; i < len; i++) {
    for (let j = 0; j < len - 1 - i; j++) {
      if (show[j].date > show[j + 1].date) { // 相邻元素两两对比
        let temp = show[j + 1] // 元素交换
        show[j + 1] = show[j]
        show[j] = temp
      }
    }
  }
  let showindex = show.findIndex(s => { return s.date === NOW})
  if (showindex === -1) {
    // 如果当前日期没有演出，那么就要查找整个日期里面和今天最相近的那天的index
    for (let idx = 0; idx < show.length; idx++) {
      if(show[idx].date > NOW) {
        // console.log(idx)
        // console.log(show[idx])
        showindex = idx - 1
        break
      }
    }
  }
  let arr = show.slice(0, showindex - 1)
    show.splice(0, showindex)
    show.push(...arr)
  if (show) {
    let currentshow = show.slice(start, end)
    // 全部剧目数组生成
    response = {
      msg:'获取到全部演出数据',
      length: show.length,
      allShows: currentshow
    }
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'数据获取失败'})
  }

})
// 获取所有剧院和演出厅信息（获取到演出厅的级联选择框）
server.get('/getlocation', (req, res) => {
  // // 需要返回的级联数据
  // let clocation = []
  // 返回的数据
  let response = {}
  if (location) {
    // 级联数据生成成功
    response = {
      msg:'数据获取成功',
      location: location
    }
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'数据获取失败'})
  }
})
// 通过级联选择框的数据来获得对应的座位图
server.get('/addshowseatmap', (req, res) => {
  let postData = req.body
  let path = postData.path
  let id = parseInt(postData.id)
  let currentdata = []
  // 返回的数据
  let response = {}
  // 查询对应剧院
  function tFn (p) {
    return p.path === path
  }
  // 查找到当前传递过来的id对应的剧院
  let theaterId = THEATHERDATA.findIndex(tFn)
  if (theaterId !== -1) {
    currentdata = THEATHERDATA[theaterId].theatreHall[id]
    response = {
      msg: '数据获取成功',
      hallData: currentdata
    }
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'数据获取失败'})
  }
})
// 在showManage内修改演出数据
server.get('/changeshow', (req, res) => {
  // 当前剧院的所有演出
  let allshow = []
  let postData = req.body
  let path = postData.theater
  let pathindex = 0
  let currentshowindex
  // console.log(postData)
  let oData = {}
  console.log(path)
  // 返回的数据
  let response = {}
  // 查找对应剧院idx
  SHOWDATA.forEach((info, idx) => {
    if (info.path === path) {
      pathindex = idx
    }
  })
  console.log(SHOWDATA[pathindex])
  // 通过ID查找对应的剧目
  SHOWDATA[pathindex].theaterShows.showInfo.forEach((item, index) => {
    if (item.id === postData.id) {
      currentshowindex = index
    }
  })
  oData = SHOWDATA[pathindex].theaterShows.showInfo[currentshowindex]
  console.log(compareObj.compare(oData, postData))
  // console.log(currentshowindex)
  if (currentshowindex !== -1) {
    // 查找到了这个剧目的下标
    if (compareObj.compare(oData, postData)) {
      // 前后两次数据没有修改
      response = {
        msg: '数据未修改'
      }
      res.status(203).send(response)
    } else {
      SHOWDATA[pathindex].theaterShows.showInfo[currentshowindex] = postData
      response = {
        msg: '数据修改成功',
        showData: allshow
      }
      res.status(200).send(response)
    }
  } else {
    res.status(200).send({msg:'数据修改失败'})
  }
})
// 在addshowdialog中添加剧目
server.get('/addnewshow', (req, res) => {
  let postData = req.body
  // 返回的数据
  let response = {}
  // 查询对应剧院
  function tFn (p) {
    return p.path === postData.theater
  }
  // 查找到当前传递过来的id对应的剧院
  let theaterId = REALSHOW.findIndex(tFn)
  if (theaterId !== -1) {
    // 如果找到对应的剧院就把传入的data push进数组
    REALSHOW[theaterId].theaterShows.showInfo.push(postData)
    margedata()
    response = {
      msg: '添加剧目成功',
      showData: REALSHOW[theaterId]
    }
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'数据添加失败'})
  }
})
// 在showManage中的搜索功能
server.get('/searchshow', (req, res) => {
  console.log(req.body)
  let s = req.body.search.split(' ')
  console.log(s)
  let start = req.body.star
  let end = req.body.end
   // 用于放所有的演出数据
   let searchshow = []
   // 返回的数据
   let response = {}
   SHOWDATA.forEach(item => {
     // 将所有剧场的演出全部放入一个数组
     Array.prototype.push.apply(searchshow, item.theaterShows.showInfo)
   })
   let searcharr = []
      if (s.length > 0) {
        console.log('开始搜索')
        for (let i = 0; i < s.length; i++) {
          let showdata = searcharr.length > 0 ? searcharr:searchshow
            // filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
          searcharr = showdata.filter(data => {
            // some() 方法用于检测数组中的元素是否满足指定条件;
            // some() 方法会依次执行数组的每个元素：
            return Object.keys(data).some(key => {
              // indexOf() 返回某个指定的字符在某个字符串中首次出现的位置，如果没有找到就返回-1；
              // 该方法对大小写敏感！所以之前需要toLowerCase()方法将所有查询到内容变为小写。
              return String(data[key]).toLowerCase().indexOf(s[i]) > -1
            })
            })
            console.log(`搜索第${i}关键字${s[i]},结果有${searcharr.length}个`)
          }
        }
      console.log(searcharr.length)
    // 处理搜索后的数据
    bubbleSort(searcharr)
    // 把已经演出过的演出放在数组末尾
    let showindex
    searcharr.forEach((item, idx) => {
      if (item.date === NOW) {
        showindex = idx
      }
    })
    let arr = searcharr.slice(0, showindex - 1)
    searcharr.splice(0, showindex)
    let cshows = searcharr.concat(arr)
    if (cshows.length > 0) {
      response = {
        msg: '数据获取成功',
        length: cshows.length,
        showdata: cshows.slice(start, end),
      }
      res.status(200).send(response)
    } else {
      res.status(200).send({
        msg:'无数据',
        showdata: []
      })
    }
})
// 获取所有用户数据
server.get('/getalluser',(req, res) => {
  let start = req.url.split('?')[1].split('&')[0].split('=')[1]
  let end = req.url.split('?')[1].split('&')[1].split('=')[1]
  // 返回数据
  let response = {}
  if (USERDATA) {
    response = {
      msg: '数据获取成功',
      userData: USERDATA.slice(start, end),
      length: USERDATA.length
    }
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'用户数据获取失败'})
  }
})
// 通过ID更改用户的状态
server.get('/changeuserstatus', (req, res) => {
  // 用户ID
  let url = req.url.split('?')[1].split('&')
  let id = url[0].split('=')[1]
  console.log(id)
  let currentUser = []
  // 这里ID对应的就是在userData中的index
  if (USERDATA[id]) {
    USERDATA[id].useable = !USERDATA[id].useable
    currentUser = USERDATA[id]
    response = {
      msg: '用户状态更改成功',
      userData: currentUser
    }
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'用户状态更改失败'})
  }
})
// 通过ID更改评论的状态
server.get('/commentstatus', (req, res) => {
  let url = req.url.split('?')[1].split('&')
  let id = url[0].split('=')[1]
  let cid = url[1].split('=')[1]
  let currentUser = []
  // 查询对应剧目
  function sFn (s) {
    // eslint-disable-next-line eqeqeq
    return s.commentid == cid
  }
  let currentid = USERDATA[id].comments.findIndex(sFn)
  if (currentid !== -1) {
    USERDATA[id].comments[currentid].status = !USERDATA[id].comments[currentid].status
    currentUser = USERDATA[id]
    response = {
      msg: '评论状态更改成功',
      userData: currentUser
    }
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'用户状态更改失败'})
  }
})
// 通过ID删除用户评论
server.get('/deletecomment', (req, res) => {
  let url = req.url.split('?')[1].split('&')
  let id = url[0].split('=')[1]
  let cid = url[1].split('=')[1]
  let currentUser = []
  // 查询对应剧目
  function sFn (s) {
    // eslint-disable-next-line eqeqeq
    return s.commentid == cid
  }
  let currentid = USERDATA[id].comments.findIndex(sFn)
  if (currentid !== -1) {
    USERDATA[id].comments.splice(currentid, 1)
    currentUser = USERDATA[id]
    response = {
      msg: '评论删除成功',
      userData: currentUser
    }
    res.status(200).send(response)
  } else {
    res.status(200).send({msg:'评论删除失败'})
  }
})
server.use(middlewares)
// 导入路由
server.use(router)
// 在3003端口开服务
server.listen(3033, () => {
  console.log('JSON Server is running')
})
